home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / devel / vbcc-src / parse_expr.c < prev    next >
C/C++ Source or Header  |  1999-01-01  |  19KB  |  785 lines
  1. /*  $VER: vbcc (parse_expr.c) V0.5  */
  2.  
  3. #include "vbc.h"
  4.  
  5. static char FILE_[]=__FILE__;
  6.  
  7. np expression(void)
  8. /*  Komma-Ausdruecke  */
  9. {
  10.   np left,right,new;
  11.   left=assignment_expression();
  12.   if(!left->flags) return 0;
  13.   killsp();
  14.   while(*s==','){
  15.     s++;
  16.     killsp();
  17.     right=assignment_expression();
  18.     new=mymalloc(NODES);
  19.     new->left=left;
  20.     new->right=right;
  21.     new->ntyp=0;
  22.     new->flags=KOMMA;
  23.     left=new;
  24.     killsp();
  25.   }
  26.   return left;
  27. }
  28. np assignment_expression(void)
  29. /*  Zuweisungsausdruecke  */
  30. {
  31.   np left,new;int c=0;
  32.   left=conditional_expression();
  33.   killsp();
  34.   if(*s!='='&&s[1]!='='&&s[2]!='=') return left;
  35.   if(*s=='=') {c=ASSIGN;s++;}
  36.   else if(*s=='*'&&s[1]=='=') {c=ASSIGNMULT;s+=2;}  
  37.   else if(*s=='/'&&s[1]=='=') {c=ASSIGNDIV;s+=2;}   
  38.   else if(*s=='%'&&s[1]=='=') {c=ASSIGNMOD;s+=2;}   
  39.   else if(*s=='+'&&s[1]=='=') {c=ASSIGNADD;s+=2;}   
  40.   else if(*s=='-'&&s[1]=='=') {c=ASSIGNSUB;s+=2;}   
  41.   else if(*s=='&'&&s[1]=='=') {c=ASSIGNAND;s+=2;}   
  42.   else if(*s=='^'&&s[1]=='=') {c=ASSIGNXOR;s+=2;}   
  43.   else if(*s=='|'&&s[1]=='=') {c=ASSIGNOR;s+=2;}    
  44.   else if(*s=='<'&&s[1]=='<') {c=ASSIGNLSHIFT;s+=3;}
  45.   else if(*s=='>'&&s[1]=='>') {c=ASSIGNRSHIFT;s+=3;}
  46.   else return left;
  47.   new=mymalloc(NODES);
  48.   new->left=left;
  49.   new->ntyp=0;
  50.   if(c==ASSIGN){
  51.     new->right=assignment_expression();
  52.     new->flags=ASSIGN;
  53.   }else{
  54.     /*  ASSIGNOP(a,b)->ASSIGN(a,OP(a,b))    */
  55.     new->flags=ASSIGNADD;   /* nur um zum Merken, dass nur einmal */
  56.                             /* ausgewertet werden darf            */
  57.     new->right=mymalloc(NODES);
  58.     new->right->left=left;
  59.     new->right->right=assignment_expression();
  60.     new->right->ntyp=0;
  61.     if(c==ASSIGNMULT) new->right->flags=MULT;
  62.     else if(c==ASSIGNDIV) new->right->flags=DIV;
  63.     else if(c==ASSIGNMOD) new->right->flags=MOD;
  64.     else if(c==ASSIGNADD) new->right->flags=ADD;
  65.     else if(c==ASSIGNSUB) new->right->flags=SUB;
  66.     else if(c==ASSIGNAND) new->right->flags=AND;
  67.     else if(c==ASSIGNXOR) new->right->flags=XOR;
  68.     else if(c==ASSIGNOR) new->right->flags=OR;
  69.     else if(c==ASSIGNLSHIFT) new->right->flags=LSHIFT;
  70.     else if(c==ASSIGNRSHIFT) new->right->flags=RSHIFT;
  71.   }
  72.   return new;
  73. }
  74. np conditional_expression(void)
  75. /*  Erledigt ? :   */
  76. {
  77.   np left,new;
  78.   left=logical_or_expression();
  79.   killsp();
  80.   if(*s=='?'){   
  81.     s++;killsp();
  82.     new=mymalloc(NODES);
  83.     new->flags=COND;
  84.     new->ntyp=0;
  85.     new->left=left;
  86.     new->right=mymalloc(NODES);
  87.     new->right->flags=COLON;
  88.     new->right->ntyp=0;
  89.     new->right->left=expression();
  90.     killsp();
  91.     if(*s==':'){s++;killsp();} else error(70);
  92.     new->right->right=conditional_expression();
  93.     left=new;
  94.     killsp();
  95.   }
  96.   return left;
  97. }
  98. np logical_or_expression(void)
  99. /*  Erledigt ||  */
  100. {
  101.   np left,right,new;
  102.   left=logical_and_expression();
  103.   killsp();
  104.   while(*s=='|'&&s[1]=='|'){
  105.     s+=2;
  106.     killsp();
  107.     right=logical_and_expression();
  108.     new=mymalloc(NODES);
  109.     new->left=left;
  110.     new->right=right;
  111.     new->flags=LOR;
  112.     new->ntyp=0;
  113.     left=new;
  114.     killsp();
  115.     if(*s=='&'&&s[1]=='&') error(222);
  116.   }
  117.   return left;
  118. }
  119. np logical_and_expression(void)
  120. /*  Erledigt &&  */
  121. {
  122.   np left,right,new;
  123.   left=inclusive_or_expression();
  124.   killsp();
  125.   while(*s=='&'&&s[1]=='&'){
  126.     s+=2;
  127.     killsp();
  128.     right=inclusive_or_expression();
  129.     new=mymalloc(NODES);
  130.     new->left=left;
  131.     new->right=right;
  132.     new->flags=LAND;
  133.     new->ntyp=0;
  134.     left=new;
  135.     killsp();
  136.     if(*s=='|'&&s[1]=='|') error(222);
  137.   }
  138.   return left;
  139. }
  140. np inclusive_or_expression(void)
  141. /*  Erledigt |  */
  142. {
  143.   np left,right,new;
  144.   left=exclusive_or_expression();
  145.   killsp();
  146.   while(*s=='|'&&s[1]!='|'&&s[1]!='='){
  147.     s++;
  148.     killsp();
  149.     right=exclusive_or_expression();
  150.     new=mymalloc(NODES);
  151.     new->left=left;
  152.     new->right=right;
  153.     new->flags=OR;
  154.     new->ntyp=0;
  155.     left=new;
  156.     killsp();
  157.   }
  158.   return left;
  159. }
  160. np exclusive_or_expression(void)
  161. /*  Erledigt ^  */
  162. {
  163.   np left,right,new;
  164.   left=and_expression();
  165.   killsp();
  166.   while(*s=='^'&&s[1]!='='){
  167.     s++;
  168.     killsp();
  169.     right=and_expression();
  170.     new=mymalloc(NODES);
  171.     new->left=left;
  172.     new->right=right;
  173.     new->flags=XOR;
  174.     new->ntyp=0;
  175.     left=new;
  176.     killsp();
  177.   }
  178.   return left;
  179. }
  180. np and_expression(void)
  181. /*  Erledigt &  */
  182. {
  183.   np left,right,new;
  184.   left=equality_expression();
  185.   killsp();
  186.   while(*s=='&'&&s[1]!='&'&&s[1]!='='){
  187.     s++;
  188.     killsp();
  189.     right=equality_expression();
  190.     new=mymalloc(NODES);
  191.     new->left=left;
  192.     new->right=right;
  193.     new->flags=AND;
  194.     new->ntyp=0;
  195.     left=new;
  196.     killsp();
  197.   }
  198.   return left;
  199. }
  200. np equality_expression(void)
  201. /*  Erledigt == und !=  */
  202. {
  203.   np left,right,new;int c;
  204.   left=relational_expression();
  205.   killsp();
  206.   while((*s=='='||*s=='!')&&s[1]=='='){
  207.     if(*s=='!') c=INEQUAL; else c=EQUAL;
  208.     s+=2;
  209.     killsp();
  210.     right=relational_expression();
  211.     new=mymalloc(NODES);
  212.     new->left=left;
  213.     new->right=right;
  214.     new->flags=c;
  215.     new->ntyp=0;
  216.     left=new;
  217.     killsp();
  218.   }
  219.   return left;
  220. }
  221. np relational_expression(void)
  222. /*  Erledigt <,>,<=,>=  */
  223. {
  224.   np left,right,new;int c;
  225.   left=shift_expression();
  226.   killsp();
  227.   while((*s=='<'&&s[1]!='<')||(*s=='>'&&s[1]!='>')){
  228.     if(*s++=='<'){
  229.       if(*s=='='){s++;c=LESSEQ;}else c=LESS;
  230.     }else{
  231.       if(*s=='='){s++;c=GREATEREQ;}else c=GREATER;
  232.     }
  233.     killsp();
  234.     right=shift_expression();
  235.     new=mymalloc(NODES);
  236.     new->left=left;
  237.     new->right=right;
  238.     new->flags=c;
  239.     new->ntyp=0;
  240.     left=new;
  241.     killsp();
  242.   }
  243.   return left;
  244. }
  245. np shift_expression(void)
  246. /*  Erledigt <<,>>  */
  247. {
  248.   np left,right,new;int c;
  249.   left=additive_expression();
  250.   killsp();
  251.   while((*s=='<'&&s[1]=='<'&&s[2]!='=')||(*s=='>'&&s[1]=='>'&&s[2]!='=')){
  252.     if(*s=='<') c=LSHIFT; else c=RSHIFT;
  253.     s+=2;
  254.     killsp();
  255.     right=additive_expression();
  256.     new=mymalloc(NODES);
  257.     new->left=left;
  258.     new->right=right;
  259.     new->flags=c;
  260.     new->ntyp=0;
  261.     left=new;
  262.     killsp();
  263.   }
  264.   return left;
  265. }
  266. np additive_expression(void)
  267. /*  Erledigt +,-  */
  268. {
  269.   np left,right,new;int c;
  270.   left=multiplicative_expression();
  271.   killsp();
  272.   while((*s=='+'||*s=='-')&&s[1]!='='){
  273.     if(*s++=='+') c=ADD; else c=SUB;
  274.     killsp();
  275.     right=multiplicative_expression();
  276.     new=mymalloc(NODES);
  277.     new->left=left;
  278.     new->right=right;
  279.     new->flags=c;
  280.     new->ntyp=0;
  281.     left=new;
  282.     killsp();
  283.   }
  284.   return left;
  285. }
  286. np multiplicative_expression(void)
  287. /*  Erledigt *,/,%  */
  288. {
  289.   np left,right,new;int c;
  290.   left=cast_expression();
  291.   killsp();
  292.   while((*s=='*'||*s=='/'||*s=='%')&&s[1]!='='){
  293.     if(*s=='*') c=MULT; else {if(*s=='/') c=DIV; else c=MOD;}
  294.     s++;
  295.     killsp();
  296.     right=cast_expression();
  297.     new=mymalloc(NODES);
  298.     new->left=left;
  299.     new->right=right;
  300.     new->flags=c;
  301.     new->ntyp=0;
  302.     left=new;
  303.     killsp();
  304.   }
  305.   return left;
  306. }
  307. np cast_expression(void)
  308. /*  Erledigt (typ)  */
  309. {
  310.   np new;char *imerk,buff[MAXI];
  311.   killsp();
  312.   if(*s!='('||!declaration(1)) return unary_expression();
  313.   s++;killsp();
  314.   new=mymalloc(NODES);
  315.   new->flags=CAST;
  316.   new->right=0;
  317.   imerk=ident;ident=buff;
  318.   new->ntyp=declarator(declaration_specifiers());
  319.   ident=imerk;
  320.   killsp();
  321.   if(*s!=')') error(59); else s++;
  322.   new->left=cast_expression();
  323.   return new;
  324. }
  325. np unary_expression(void)
  326. /*  Erledigt !,~,++,--,+,-,*,&,sizeof,__typeof  */
  327. {
  328.   np new;char *merk=s,buff[MAXI];
  329.   killsp();
  330.   if((*s!='s'&&*s!='_'&&*s!='+'&&*s!='-'&&*s!='&'&&*s!='*'&&*s!='~'&&*s!='!')||s[1]=='=') return postfix_expression();
  331.   if(*s=='s'||*s=='_'){
  332.     int fszof;
  333.     merk=s;cpbez(buff,0);s=merk;
  334.     if(strcmp("sizeof",buff)&&strcmp("__typeof",buff)){
  335.       return postfix_expression();
  336.     }else{
  337.       if(*buff=='s') fszof=1; else fszof=0;
  338.       s+=strlen(buff);
  339.       killsp();
  340.       new=mymalloc(NODES);
  341.       new->flags=CEXPR;
  342.       new->ntyp=mymalloc(TYPS);
  343.       if(fszof){
  344.     if(HAVE_INT_SIZET)
  345.       new->ntyp->flags=(UNSIGNED|INT);
  346.     else
  347.       if(fszof) new->ntyp->flags=(UNSIGNED|LONG);
  348.       } else
  349.     new->ntyp->flags=INT;
  350.       new->ntyp->next=0;
  351.       new->right=0;
  352.       new->left=0;
  353.       if(*s=='('&&declaration(1)){
  354.     struct Typ *t;
  355.     s++;killsp();
  356.     merk=ident;ident=buff;
  357.     t=declarator(declaration_specifiers());
  358.     if(type_uncomplete(t)) error(176);
  359.     ident=merk;
  360.     if(fszof){
  361.       if(HAVE_INT_SIZET)
  362.         new->val.vuint=zul2zui(zl2zul(szof(t)));
  363.       else
  364.         new->val.vulong=zl2zul(szof(t));
  365.     } else
  366.       new->val.vint=zl2zi(l2zl(t->flags));
  367.     freetyp(t);
  368.     killsp();
  369.     if(*s!=')') error(59); else s++;
  370.       }else{
  371.     np tree;
  372.     killsp();
  373.     tree=unary_expression();
  374.     if(!tree||!type_expression(tree)){
  375.       if(fszof){
  376.         if(HAVE_INT_SIZET)
  377.           new->val.vuint=zul2zui(ul2zul(0UL));
  378.         else
  379.           new->val.vulong=ul2zul(0UL);
  380.         error(73);
  381.       }else{
  382.         new->val.vint=zl2zi(l2zl(-1L));
  383.       }
  384.     }else{
  385.       if(fszof){
  386.         if(type_uncomplete(tree->ntyp)) error(176);
  387.         if(HAVE_INT_SIZET)
  388.           new->val.vuint=zul2zui(zl2zul(szof(tree->ntyp)));
  389.         else
  390.           new->val.vulong=zl2zul(szof(tree->ntyp));
  391.       }else{
  392.         new->val.vint=zl2zi(l2zl(tree->ntyp->flags));
  393.       }
  394.     }
  395.     if(tree) free_expression(tree);killsp();
  396.       }
  397.       return new;
  398.     }
  399.   }
  400.   new=mymalloc(NODES);
  401.   new->right=0;
  402.   new->ntyp=0;
  403.   if(*s=='+'){
  404.     if(s[1]=='+'){
  405.       s+=2;
  406.       new->left=unary_expression();
  407.       new->flags=PREINC;
  408.     }else{
  409.       s++;free(new);
  410.       return cast_expression();
  411.     }
  412.   }else if(*s=='-'){
  413.     if(s[1]=='-'){
  414.       s+=2;
  415.       new->left=unary_expression();
  416.       new->flags=PREDEC;
  417.     }else{
  418.       s++;
  419.       new->left=cast_expression();
  420.       new->flags=MINUS;
  421.     }
  422.   }else if(*s=='&'){
  423.     s++;
  424.     new->left=cast_expression();
  425.     new->flags=ADDRESS;
  426.   }else if(*s=='*'){
  427.     s++;
  428.     new->left=cast_expression();
  429.     new->flags=CONTENT;
  430.   }else if(*s=='~'){
  431.     s++;
  432.     new->left=cast_expression();
  433.     new->flags=KOMPLEMENT;
  434.   }else if(*s=='!'){
  435.     s++;
  436.     new->left=cast_expression();
  437.     new->flags=NEGATION;
  438.   }
  439.   new->right=0;
  440.   new->ntyp=0;
  441.   return new;
  442. }
  443. np postfix_expression(void)
  444. /*  Erledigt [],(),.,->,++,--  */
  445. {
  446.   np new,left;
  447.   left=primary_expression();
  448.   killsp();
  449.   while(*s=='['||*s=='('||*s=='.'||(*s=='-'&&((s[1]=='-')||(s[1]=='>')))
  450.     ||(*s=='+'&&s[1]=='+')){
  451.     new=mymalloc(NODES);
  452.     new->ntyp=0;
  453.     new->right=0;
  454.     new->left=left;
  455.     if(*s=='-'){
  456.       s++;
  457.       if(*s=='-'){
  458.     s++;
  459.     new->flags=POSTDEC;
  460.       }else{
  461.     s++; killsp();
  462.     new->flags=DSTRUCT;
  463.     new->right=identifier_expression();
  464.     new->right->flags=MEMBER;
  465.     new->left=mymalloc(NODES);
  466.     new->left->ntyp=0;
  467.     new->left->left=left;
  468.     new->left->right=0;
  469.     new->left->flags=CONTENT;
  470.       }
  471.     }else if(*s=='['){
  472.       s++; killsp();
  473.       new->flags=CONTENT;
  474.       new->left=mymalloc(NODES);
  475.       new->left->flags=ADD;
  476.       new->left->ntyp=0;
  477.       new->left->left=left;
  478.       new->left->right=expression();
  479.       killsp();
  480.       if(*s!=']') error(62); else s++;
  481.     }else if(*s=='+'){
  482.       s+=2;
  483.       new->flags=POSTINC;
  484.     }else if(*s=='.'){
  485.       s++;killsp();
  486.       new->right=identifier_expression();
  487.       new->flags=DSTRUCT;
  488.       new->right->flags=MEMBER;
  489.     }else if(*s=='('){
  490.       struct argument_list *al,*first_alist=0,*last_alist=0;np n;
  491.       s++;killsp();
  492.       new->flags=CALL;
  493.       new->right=0;
  494.       while(*s!=')'){
  495.     n=assignment_expression();
  496.     al=mymalloc(sizeof(struct argument_list));
  497.     al->arg=n;al->next=0;
  498.     if(last_alist){
  499.       last_alist->next=al;
  500.       last_alist=al;
  501.     }else{
  502.       last_alist=first_alist=al;
  503.     }
  504.     killsp();
  505.     if(*s==',') {s++;killsp();if(*s==')') error(59);}
  506.     else if(*s!=')') error(57);
  507.     
  508.       }
  509.       new->alist=first_alist;
  510.       if(*s!=')') error(59); else s++;
  511.     }
  512.     left=new;
  513.     killsp();
  514.   }
  515.   return left;
  516. }
  517. np primary_expression(void)
  518. /*  primary-expressions (Konstanten,Strings,(expr),Identifier)  */
  519. {
  520.   np new;
  521.   if((*s>='0'&&*s<='9')||*s=='.') return constant_expression();
  522.   if(*s=='\"'||*s=='\''||(*s=='L'&&(s[1]=='\''||s[1]=='\"'))) return string_expression();
  523.   if(*s=='('){
  524.     s++;killsp();
  525.     new=expression();
  526.     killsp();
  527.     if(*s!=')') error(59); else s++;
  528.     return new;
  529.   }
  530.   return identifier_expression();
  531. }
  532. np string_expression(void)
  533. /*  Gibt Zeiger auf string oder Zeichenkonstante zurueck  */
  534. {
  535.   np new; char f,string[MAXINPUT],*p;int flag,val;zlong zl;
  536.   if(*s=='L') s++;    /*  Noch keine erweiterten Zeichen  */
  537.   p=string;f=*s++;
  538.   while(1){
  539.     while(*s!=f&&p<&string[MAXINPUT-1]){
  540.       if(*s=='\\'){
  541.     s++;
  542.     if(*s=='\\'){*p++='\\';s++;continue;}
  543.     if(*s=='n'){*p++='\n';s++;continue;}
  544.     if(*s=='t'){*p++='\t';s++;continue;}
  545.     if(*s=='r'){*p++='\r';s++;continue;}
  546.     if(*s=='v'){*p++='\v';s++;continue;}
  547.     if(*s=='b'){*p++='\b';s++;continue;}
  548.     if(*s=='f'){*p++='\f';s++;continue;}
  549.     if(*s=='a'){*p++='\a';s++;continue;}
  550.     if(*s=='\?'){*p++='\?';s++;continue;}
  551.     if(*s=='\''){*p++='\'';s++;continue;}
  552.     if(*s=='\"'){*p++='\"';s++;continue;}
  553.     flag=val=0;
  554.     while(*s>='0'&&*s<='7'&&flag<3){
  555.       val=val*8+*s-'0';
  556.       s++;flag++;
  557.     }
  558.     if(flag){*p++=val;continue;}
  559.     if(*s=='x'){
  560.       s++;val=0;
  561.       while((*s>='0'&&*s<='9')||(*s>='a'&&*s<='f')||(*s>='A'&&*s<='F')){
  562.         val=val*16;
  563.         if(*s>='0'&&*s<='9') val+=*s-'0';
  564.         if(*s>='a'&&*s<='f') val+=*s-'a'+10;
  565.         if(*s>='A'&&*s<='F') val+=*s-'A'+10;
  566.         s++;
  567.       }
  568.       *p++=val;continue;
  569.     }
  570.     error(71);
  571.       }
  572.       *p++=*s++;
  573.     }
  574.     if(*s!=f) error(74); else s++;
  575.     killsp();
  576.     if(f!='\"'||*s!=f) break; else s++;
  577.   }
  578.   *p=0;
  579.   new=mymalloc(NODES);
  580.   new->ntyp=mymalloc(TYPS);
  581.   if(f=='\"'){
  582.     struct const_list *cl,**prev;int i;
  583.     new->ntyp->flags=ARRAY;
  584.     new->ntyp->size=l2zl((long)(p-string)+1);
  585.     new->ntyp->next=mymalloc(TYPS);
  586.     new->ntyp->next->flags=STRINGCONST|CHAR;
  587.     new->ntyp->next->next=0;
  588.     new->flags=STRING;
  589.     prev=&new->cl;
  590.     for(i=0;i<p-string+1;i++){
  591.       cl=mymalloc(CLS);
  592.       cl->next=0;
  593.       cl->tree=0;
  594.       cl->other=mymalloc(CLS);
  595.       cl->other->next=cl->other->other=0;
  596.       cl->other->tree=0;
  597.       cl->other->val.vchar=zl2zc(l2zl((long)string[i]));
  598.       *prev=cl;
  599.       prev=&cl->next;
  600.     }
  601.     /*        new->identifier=add_identifier(string,p-string);*/
  602.     new->val.vlong=l2zl(0L);
  603.   }else{
  604.     char *l;
  605.     new->ntyp->flags=CONST|INT;
  606.     new->ntyp->next=0;
  607.     new->flags=CEXPR;
  608.     zl=l2zl(0L);
  609.     p--;
  610.     if(p>string) error(72);
  611.     for(BIGENDIAN?(l=string):(l=p);BIGENDIAN?(l<=p):(l>=string);BIGENDIAN?(l++):(l--)){
  612.       /*  zl=zl<<CHAR_BIT+*p  */
  613.       zl=zllshift(zl,char_bit);
  614.       zl=zladd(zl,l2zl((long)*l));
  615.       new->val.vint=zl2zi(zl);
  616.     }
  617.   }
  618.   new->left=new->right=0;
  619.   return new;
  620. }
  621. np constant_expression(void)
  622. /*  Gibt Zeiger auf erzeugt Struktur fuer Konstante zurueck */
  623. {
  624.   np new; zdouble db;
  625.   zulong value,zbase,digit;unsigned long base=10,t;
  626.   char *merk;int warned=0;
  627.   merk=s;
  628.   value=ul2zul(0L);
  629.   new=mymalloc(NODES);
  630.   new->ntyp=mymalloc(TYPS);
  631.   new->ntyp->flags=0;
  632.   new->ntyp->next=0;
  633.   new->flags=CEXPR;
  634.   new->left=new->right=0;
  635.   new->sidefx=0;
  636.   if(*s=='0'){
  637.     s++;
  638.     if(*s=='x'||*s=='X'){s++;base=16;} else base=8;
  639.   }
  640.   zbase=ul2zul(base);
  641.   if(*s>='0'&&*s<='9') t=*s-'0'; 
  642.   else if(*s>='a'&&*s<='f') t=*s-'a'+10; 
  643.   else if(*s>='A'&&*s<='F') t=*s-'A'+10;
  644.   else t=20;
  645.   while(t<base){
  646.     digit=ul2zul(t);
  647.     if(!warned){
  648.       if(!zulleq(value,zuldiv(zulsub(t_max[UNSIGNED|LONG],digit),zbase)))
  649.     warned=1;
  650.     }
  651.     value=zuladd(zulmult(value,zbase),digit);
  652.     s++;
  653.     if(*s>='0'&&*s<='9') t=*s-'0'; 
  654.     else if(*s>='a'&&*s<='f') t=*s-'a'+10; 
  655.     else if(*s>='A'&&*s<='F') t=*s-'A'+10; 
  656.     else t=20;
  657.   }
  658.   while(*s=='u'||*s=='U'||*s=='l'||*s=='L'){
  659.     if(*s=='u'||*s=='U'){
  660.       if(zulleq(value,t_max[UNSIGNED|INT])) new->ntyp->flags=UNSIGNED|INT;
  661.       else               new->ntyp->flags=UNSIGNED|LONG;
  662.     }else{
  663.       if(zulleq(value,t_max[LONG])) new->ntyp->flags=LONG;
  664.       else               new->ntyp->flags=UNSIGNED|LONG;
  665.     }
  666.     s++;
  667.   }
  668.   if(*s=='.'||*s=='e'||*s=='E'){
  669.     /*  Fliesskommakonstante, ignoriert vorher berechneten Wert, falls er   */
  670.     /*  nicht dezimal und nicht 0 war (da er dann oktal war)                */
  671.     if(*merk=='0'&&!zuleqto(value,ul2zul(0UL))){
  672.       value=ul2zul(0UL);zbase=ul2zul(10UL);
  673.       while(*merk>='0'&&*merk<='9'){
  674.     digit=ul2zul((unsigned long)(*merk-'0'));
  675.     value=zuladd(zulmult(value,zbase),digit);
  676.     merk++;
  677.       }
  678.       if(merk!=s) error(75);
  679.     }
  680.     db=zul2zd(value);
  681.     if(*s=='.'){
  682.       /*  Teil hinter Kommastellen    */
  683.       zdouble zquot,zbased,digit;
  684.       s++;
  685.       zbased=d2zd(10);zquot=d2zd(0.1);
  686.       while(*s>='0'&&*s<='9'){
  687.     digit=d2zd((double)(*s-'0'));
  688.     db=zdadd(db,zdmult(digit,zquot));
  689.     zquot=zddiv(zquot,zbased);
  690.     s++;
  691.       }
  692.       
  693.     }
  694.     if(*s=='e'||*s=='E'){
  695.       /*  Exponentialdarstellung  */
  696.       int exp,vorz,i;zdouble zbased;
  697.       zbased=d2zd((double)10);
  698.       s++;
  699.       if(*s=='-'){
  700.     s++;vorz=-1;
  701.       }else{
  702.     vorz=1;if(*s=='+') s++;
  703.       }
  704.       exp=0;
  705.       while(*s>='0'&&*s<='9') exp=exp*10+*s++-'0';
  706.       for(i=0;i<exp;i++){
  707.     if(vorz>0) db=zdmult(db,zbased);
  708.     else   db=zddiv(db,zbased);
  709.       }
  710.     }
  711.     new->ntyp->flags=DOUBLE;
  712.     if(*s=='f'||*s=='F'){
  713.       new->ntyp->flags=FLOAT;s++;
  714.     }else{
  715.       /*  long double werden nicht unterstuetzt und sind==double :-(  */
  716.       if(*s=='l'||*s=='L') s++;
  717.     }
  718.   }else{
  719.     if(warned) error(211);
  720.     if(new->ntyp->flags==0){
  721.       if(base==10){
  722.     if(zulleq(value,t_max[INT])) new->ntyp->flags=INT;
  723.     else if(zulleq(value,t_max[LONG])) new->ntyp->flags=LONG; 
  724.         else {new->ntyp->flags=UNSIGNED|LONG;error(212);}
  725.       }else{
  726.     if(zulleq(value,t_max[INT])) new->ntyp->flags=INT; 
  727.     else if(zulleq(value,t_max[UNSIGNED|INT])) new->ntyp->flags=UNSIGNED|INT;
  728.     else if(zulleq(value,t_max[LONG])) new->ntyp->flags=LONG;
  729.     else {new->ntyp->flags=UNSIGNED|LONG;error(212);}
  730.       }
  731.     }
  732.   }
  733.   
  734.   if(new->ntyp->flags==FLOAT) new->val.vfloat=zd2zf(db);
  735.   else if(new->ntyp->flags==DOUBLE) new->val.vdouble=db;
  736.   else if(new->ntyp->flags==INT) new->val.vint=zl2zi(zul2zl(value));
  737.   else if(new->ntyp->flags==(UNSIGNED|INT)) new->val.vuint=zul2zui(value);
  738.   else if(new->ntyp->flags==LONG) new->val.vlong=zul2zl(value);
  739.   else if(new->ntyp->flags==(UNSIGNED|LONG)) new->val.vulong=value;
  740.   else ierror(0);
  741.   return new;
  742. }
  743. np identifier_expression(void)
  744. /*  Erzeugt Identifier mit Knoten  */
  745. {
  746.   np new;char buff[MAXI];
  747.   killsp();cpbez(buff,1);
  748.   new=mymalloc(NODES);
  749.   new->flags=IDENTIFIER;
  750.   new->left=new->right=0;
  751.   new->identifier=add_identifier(buff,strlen(buff));
  752.   new->ntyp=0;
  753.   new->sidefx=0;
  754.   new->val.vlong=l2zl(0L);
  755.   if(new->identifier==empty) {error(76);new->flags=0;}
  756.   return new;
  757. }
  758. void free_alist(struct argument_list *p)
  759. /*  Gibt argument_list inkl. expressions frei  */
  760. {
  761.   struct argument_list *merk;
  762.   while(p){
  763.     merk=p->next;
  764.     if(p->arg) free_expression(p->arg);
  765.     free(p);
  766.     p=merk;
  767.   }
  768. }
  769. void free_expression(np p)
  770. /*  Gibt expression mit allen Typen etc. frei  */
  771. {
  772.   if(!p) return;
  773.   if(p->flags==ASSIGNADD){
  774.     if(!p->right){ierror(0);return;}
  775.     if(p->right->left==p->left)  p->left=0;
  776.     if(p->right->right==p->left) p->left=0;
  777.   }
  778.   if(p->flags==CALL&&p->alist) free_alist(p->alist);
  779.   if(p->ntyp) freetyp(p->ntyp);
  780.   if(p->left) free_expression(p->left);
  781.   if(p->right) free_expression(p->right);
  782.   free(p);
  783. }
  784.  
  785.